package co.com.tye.presentation.businessDelegate;

import co.com.tye.modelo.Criterios;
import co.com.tye.modelo.CriteriosEvaluadosXestudianteXcurso;
import co.com.tye.modelo.CriteriosEvaluadosXestudianteXespacio;
import co.com.tye.modelo.CriteriosEvaluadosXestudianteXservicio;
import co.com.tye.modelo.CriteriosXespacio;
import co.com.tye.modelo.CriteriosXservicio;
import co.com.tye.modelo.Curso;
import co.com.tye.modelo.Docente;
import co.com.tye.modelo.DocentePrograma;
import co.com.tye.modelo.Espacio;
import co.com.tye.modelo.Estudiante;
import co.com.tye.modelo.EstudianteCurso;
import co.com.tye.modelo.Facultad;
import co.com.tye.modelo.GruposOpciones;
import co.com.tye.modelo.HistorialCriteriosEvaluadosXestuadianteXservicio;
import co.com.tye.modelo.HistorialCriteriosEvaluadosXestudianteXespacio;
import co.com.tye.modelo.Opciones;
import co.com.tye.modelo.Permisos;
import co.com.tye.modelo.Programa;
import co.com.tye.modelo.Servicio;
import co.com.tye.modelo.TipoCriterios;
import co.com.tye.modelo.Universidad;
import co.com.tye.modelo.Usuario;
import co.com.tye.modelo.control.CriteriosEvaluadosXestudianteXcursoLogic;
import co.com.tye.modelo.control.CriteriosEvaluadosXestudianteXespacioLogic;
import co.com.tye.modelo.control.CriteriosEvaluadosXestudianteXservicioLogic;
import co.com.tye.modelo.control.CriteriosLogic;
import co.com.tye.modelo.control.CriteriosXespacioLogic;
import co.com.tye.modelo.control.CriteriosXservicioLogic;
import co.com.tye.modelo.control.CursoLogic;
import co.com.tye.modelo.control.DocenteLogic;
import co.com.tye.modelo.control.DocenteProgramaLogic;
import co.com.tye.modelo.control.EspacioLogic;
import co.com.tye.modelo.control.EstudianteCursoLogic;
import co.com.tye.modelo.control.EstudianteLogic;
import co.com.tye.modelo.control.FacultadLogic;
import co.com.tye.modelo.control.GruposOpcionesLogic;
import co.com.tye.modelo.control.HistorialCriteriosEvaluadosXestuadianteXservicioLogic;
import co.com.tye.modelo.control.HistorialCriteriosEvaluadosXestudianteXespacioLogic;
import co.com.tye.modelo.control.ICriteriosEvaluadosXestudianteXcursoLogic;
import co.com.tye.modelo.control.ICriteriosEvaluadosXestudianteXespacioLogic;
import co.com.tye.modelo.control.ICriteriosEvaluadosXestudianteXservicioLogic;
import co.com.tye.modelo.control.ICriteriosLogic;
import co.com.tye.modelo.control.ICriteriosXespacioLogic;
import co.com.tye.modelo.control.ICriteriosXservicioLogic;
import co.com.tye.modelo.control.ICursoLogic;
import co.com.tye.modelo.control.IDocenteLogic;
import co.com.tye.modelo.control.IDocenteProgramaLogic;
import co.com.tye.modelo.control.IEspacioLogic;
import co.com.tye.modelo.control.IEstudianteCursoLogic;
import co.com.tye.modelo.control.IEstudianteLogic;
import co.com.tye.modelo.control.IFacultadLogic;
import co.com.tye.modelo.control.IGruposOpcionesLogic;
import co.com.tye.modelo.control.IHistorialCriteriosEvaluadosXestuadianteXservicioLogic;
import co.com.tye.modelo.control.IHistorialCriteriosEvaluadosXestudianteXespacioLogic;
import co.com.tye.modelo.control.IOpcionesLogic;
import co.com.tye.modelo.control.IPermisosLogic;
import co.com.tye.modelo.control.IProgramaLogic;
import co.com.tye.modelo.control.IServicioLogic;
import co.com.tye.modelo.control.ITipoCriteriosLogic;
import co.com.tye.modelo.control.IUniversidadLogic;
import co.com.tye.modelo.control.IUsuarioLogic;
import co.com.tye.modelo.control.OpcionesLogic;
import co.com.tye.modelo.control.PermisosLogic;
import co.com.tye.modelo.control.ProgramaLogic;
import co.com.tye.modelo.control.ServicioLogic;
import co.com.tye.modelo.control.TipoCriteriosLogic;
import co.com.tye.modelo.control.UniversidadLogic;
import co.com.tye.modelo.control.UsuarioLogic;
import co.com.tye.modelo.dto.CriteriosDTO;
import co.com.tye.modelo.dto.CriteriosEvaluadosXestudianteXcursoDTO;
import co.com.tye.modelo.dto.CriteriosEvaluadosXestudianteXespacioDTO;
import co.com.tye.modelo.dto.CriteriosEvaluadosXestudianteXservicioDTO;
import co.com.tye.modelo.dto.CriteriosXespacioDTO;
import co.com.tye.modelo.dto.CriteriosXservicioDTO;
import co.com.tye.modelo.dto.CursoDTO;
import co.com.tye.modelo.dto.DocenteDTO;
import co.com.tye.modelo.dto.DocenteProgramaDTO;
import co.com.tye.modelo.dto.EspacioDTO;
import co.com.tye.modelo.dto.EstudianteCursoDTO;
import co.com.tye.modelo.dto.EstudianteDTO;
import co.com.tye.modelo.dto.FacultadDTO;
import co.com.tye.modelo.dto.GruposOpcionesDTO;
import co.com.tye.modelo.dto.HistorialCriteriosEvaluadosXestuadianteXservicioDTO;
import co.com.tye.modelo.dto.HistorialCriteriosEvaluadosXestudianteXespacioDTO;
import co.com.tye.modelo.dto.OpcionesDTO;
import co.com.tye.modelo.dto.PermisosDTO;
import co.com.tye.modelo.dto.ProgramaDTO;
import co.com.tye.modelo.dto.ServicioDTO;
import co.com.tye.modelo.dto.TipoCriteriosDTO;
import co.com.tye.modelo.dto.UniversidadDTO;
import co.com.tye.modelo.dto.UsuarioDTO;
import co.com.tye.presentation.businessDelegate.IBusinessDelegatorView;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.sql.*;
import java.util.Date;
import java.util.List;
import java.util.Set;


/**
* Use a Business Delegate to reduce coupling between presentation-tier clients and business services.
* The Business Delegate hides the underlying implementation details of the business service, such as lookup and access details of the EJB architecture.
*
* The Business Delegate acts as a client-side business abstraction; it provides an abstraction for, and thus hides,
* the implementation of the business services. Using a Business Delegate reduces the coupling between presentation-tier clients and
* the system's business services. Depending on the implementation strategy, the Business Delegate may shield clients from possible
* volatility in the implementation of the business service API. Potentially, this reduces the number of changes that must be made to the
* presentation-tier client code when the business service API or its underlying implementation changes.
*
* However, interface methods in the Business Delegate may still require modification if the underlying business service API changes.
* Admittedly, though, it is more likely that changes will be made to the business service rather than to the Business Delegate.
*
* Often, developers are skeptical when a design goal such as abstracting the business layer causes additional upfront work in return
* for future gains. However, using this pattern or its strategies results in only a small amount of additional upfront work and provides
* considerable benefits. The main benefit is hiding the details of the underlying service. For example, the client can become transparent
* to naming and lookup services. The Business Delegate also handles the exceptions from the business services, such as java.rmi.Remote
* exceptions, Java Messages Service (JMS) exceptions and so on. The Business Delegate may intercept such service level exceptions and
* generate application level exceptions instead. Application level exceptions are easier to handle by the clients, and may be user friendly.
* The Business Delegate may also transparently perform any retry or recovery operations necessary in the event of a service failure without
* exposing the client to the problem until it is determined that the problem is not resolvable. These gains present a compelling reason to
* use the pattern.
*
* Another benefit is that the delegate may cache results and references to remote business services. Caching can significantly improve performance,
* because it limits unnecessary and potentially costly round trips over the network.
*
* A Business Delegate uses a component called the Lookup Service. The Lookup Service is responsible for hiding the underlying implementation
* details of the business service lookup code. The Lookup Service may be written as part of the Delegate, but we recommend that it be
* implemented as a separate component, as outlined in the Service Locator pattern (See "Service Locator" on page 368.)
*
* When the Business Delegate is used with a Session Facade, typically there is a one-to-one relationship between the two.
* This one-to-one relationship exists because logic that might have been encapsulated in a Business Delegate relating to its interaction
* with multiple business services (creating a one-to-many relationship) will often be factored back into a Session Facade.
*
* Finally, it should be noted that this pattern could be used to reduce coupling between other tiers, not simply the presentation and the
* business tiers.
*
* @author Zathura Code Generator http://code.google.com/p/zathura/
* www.zathuracode.org
*
*/
@Scope("singleton")
@Service("BusinessDelegatorView")
public class BusinessDelegatorView implements IBusinessDelegatorView {
    @Autowired
    private ICriteriosLogic criteriosLogic;
    @Autowired
    private ICriteriosEvaluadosXestudianteXcursoLogic criteriosEvaluadosXestudianteXcursoLogic;
    @Autowired
    private ICriteriosEvaluadosXestudianteXespacioLogic criteriosEvaluadosXestudianteXespacioLogic;
    @Autowired
    private ICriteriosEvaluadosXestudianteXservicioLogic criteriosEvaluadosXestudianteXservicioLogic;
    @Autowired
    private ICriteriosXespacioLogic criteriosXespacioLogic;
    @Autowired
    private ICriteriosXservicioLogic criteriosXservicioLogic;
    @Autowired
    private ICursoLogic cursoLogic;
    @Autowired
    private IDocenteLogic docenteLogic;
    @Autowired
    private IDocenteProgramaLogic docenteProgramaLogic;
    @Autowired
    private IEspacioLogic espacioLogic;
    @Autowired
    private IEstudianteLogic estudianteLogic;
    @Autowired
    private IEstudianteCursoLogic estudianteCursoLogic;
    @Autowired
    private IFacultadLogic facultadLogic;
    @Autowired
    private IGruposOpcionesLogic gruposOpcionesLogic;
    @Autowired
    private IHistorialCriteriosEvaluadosXestuadianteXservicioLogic historialCriteriosEvaluadosXestuadianteXservicioLogic;
    @Autowired
    private IHistorialCriteriosEvaluadosXestudianteXespacioLogic historialCriteriosEvaluadosXestudianteXespacioLogic;
    @Autowired
    private IOpcionesLogic opcionesLogic;
    @Autowired
    private IPermisosLogic permisosLogic;
    @Autowired
    private IProgramaLogic programaLogic;
    @Autowired
    private IServicioLogic servicioLogic;
    @Autowired
    private ITipoCriteriosLogic tipoCriteriosLogic;
    @Autowired
    private IUniversidadLogic universidadLogic;
    @Autowired
    private IUsuarioLogic usuarioLogic;

    public List<Criterios> getCriterios() throws Exception {
        return criteriosLogic.getCriterios();
    }

    public void saveCriterios(Criterios entity) throws Exception {
        criteriosLogic.saveCriterios(entity);
    }

    public void deleteCriterios(Criterios entity) throws Exception {
        criteriosLogic.deleteCriterios(entity);
    }

    public void updateCriterios(Criterios entity) throws Exception {
        criteriosLogic.updateCriterios(entity);
    }

    public Criterios getCriterios(Integer idcriterios)
        throws Exception {
        Criterios criterios = null;

        try {
            criterios = criteriosLogic.getCriterios(idcriterios);
        } catch (Exception e) {
            throw e;
        }

        return criterios;
    }

    public List<Criterios> findByCriteriaInCriterios(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return criteriosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Criterios> findPageCriterios(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return criteriosLogic.findPageCriterios(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberCriterios() throws Exception {
        return criteriosLogic.findTotalNumberCriterios();
    }

    public List<CriteriosDTO> getDataCriterios() throws Exception {
        return criteriosLogic.getDataCriterios();
    }

    public List<CriteriosEvaluadosXestudianteXcurso> getCriteriosEvaluadosXestudianteXcurso()
        throws Exception {
        return criteriosEvaluadosXestudianteXcursoLogic.getCriteriosEvaluadosXestudianteXcurso();
    }

    public void saveCriteriosEvaluadosXestudianteXcurso(
        CriteriosEvaluadosXestudianteXcurso entity) throws Exception {
        criteriosEvaluadosXestudianteXcursoLogic.saveCriteriosEvaluadosXestudianteXcurso(entity);
    }

    public void deleteCriteriosEvaluadosXestudianteXcurso(
        CriteriosEvaluadosXestudianteXcurso entity) throws Exception {
        criteriosEvaluadosXestudianteXcursoLogic.deleteCriteriosEvaluadosXestudianteXcurso(entity);
    }

    public void updateCriteriosEvaluadosXestudianteXcurso(
        CriteriosEvaluadosXestudianteXcurso entity) throws Exception {
        criteriosEvaluadosXestudianteXcursoLogic.updateCriteriosEvaluadosXestudianteXcurso(entity);
    }

    public CriteriosEvaluadosXestudianteXcurso getCriteriosEvaluadosXestudianteXcurso(
        Integer idcriteriosEvaluadosXestudianteXcurso)
        throws Exception {
        CriteriosEvaluadosXestudianteXcurso criteriosEvaluadosXestudianteXcurso = null;

        try {
            criteriosEvaluadosXestudianteXcurso = criteriosEvaluadosXestudianteXcursoLogic.getCriteriosEvaluadosXestudianteXcurso(idcriteriosEvaluadosXestudianteXcurso);
        } catch (Exception e) {
            throw e;
        }

        return criteriosEvaluadosXestudianteXcurso;
    }

    public List<CriteriosEvaluadosXestudianteXcurso> findByCriteriaInCriteriosEvaluadosXestudianteXcurso(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return criteriosEvaluadosXestudianteXcursoLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public List<CriteriosEvaluadosXestudianteXcurso> findPageCriteriosEvaluadosXestudianteXcurso(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return criteriosEvaluadosXestudianteXcursoLogic.findPageCriteriosEvaluadosXestudianteXcurso(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberCriteriosEvaluadosXestudianteXcurso()
        throws Exception {
        return criteriosEvaluadosXestudianteXcursoLogic.findTotalNumberCriteriosEvaluadosXestudianteXcurso();
    }

    public List<CriteriosEvaluadosXestudianteXcursoDTO> getDataCriteriosEvaluadosXestudianteXcurso()
        throws Exception {
        return criteriosEvaluadosXestudianteXcursoLogic.getDataCriteriosEvaluadosXestudianteXcurso();
    }

    public List<CriteriosEvaluadosXestudianteXespacio> getCriteriosEvaluadosXestudianteXespacio()
        throws Exception {
        return criteriosEvaluadosXestudianteXespacioLogic.getCriteriosEvaluadosXestudianteXespacio();
    }

    public void saveCriteriosEvaluadosXestudianteXespacio(
        CriteriosEvaluadosXestudianteXespacio entity) throws Exception {
        criteriosEvaluadosXestudianteXespacioLogic.saveCriteriosEvaluadosXestudianteXespacio(entity);
    }

    public void deleteCriteriosEvaluadosXestudianteXespacio(
        CriteriosEvaluadosXestudianteXespacio entity) throws Exception {
        criteriosEvaluadosXestudianteXespacioLogic.deleteCriteriosEvaluadosXestudianteXespacio(entity);
    }

    public void updateCriteriosEvaluadosXestudianteXespacio(
        CriteriosEvaluadosXestudianteXespacio entity) throws Exception {
        criteriosEvaluadosXestudianteXespacioLogic.updateCriteriosEvaluadosXestudianteXespacio(entity);
    }

    public CriteriosEvaluadosXestudianteXespacio getCriteriosEvaluadosXestudianteXespacio(
        Integer idcriteriosEvaluadosXestudianteXespacio)
        throws Exception {
        CriteriosEvaluadosXestudianteXespacio criteriosEvaluadosXestudianteXespacio =
            null;

        try {
            criteriosEvaluadosXestudianteXespacio = criteriosEvaluadosXestudianteXespacioLogic.getCriteriosEvaluadosXestudianteXespacio(idcriteriosEvaluadosXestudianteXespacio);
        } catch (Exception e) {
            throw e;
        }

        return criteriosEvaluadosXestudianteXespacio;
    }

    public List<CriteriosEvaluadosXestudianteXespacio> findByCriteriaInCriteriosEvaluadosXestudianteXespacio(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return criteriosEvaluadosXestudianteXespacioLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public List<CriteriosEvaluadosXestudianteXespacio> findPageCriteriosEvaluadosXestudianteXespacio(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return criteriosEvaluadosXestudianteXespacioLogic.findPageCriteriosEvaluadosXestudianteXespacio(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberCriteriosEvaluadosXestudianteXespacio()
        throws Exception {
        return criteriosEvaluadosXestudianteXespacioLogic.findTotalNumberCriteriosEvaluadosXestudianteXespacio();
    }

    public List<CriteriosEvaluadosXestudianteXespacioDTO> getDataCriteriosEvaluadosXestudianteXespacio()
        throws Exception {
        return criteriosEvaluadosXestudianteXespacioLogic.getDataCriteriosEvaluadosXestudianteXespacio();
    }

    public List<CriteriosEvaluadosXestudianteXservicio> getCriteriosEvaluadosXestudianteXservicio()
        throws Exception {
        return criteriosEvaluadosXestudianteXservicioLogic.getCriteriosEvaluadosXestudianteXservicio();
    }

    public void saveCriteriosEvaluadosXestudianteXservicio(
        CriteriosEvaluadosXestudianteXservicio entity)
        throws Exception {
        criteriosEvaluadosXestudianteXservicioLogic.saveCriteriosEvaluadosXestudianteXservicio(entity);
    }

    public void deleteCriteriosEvaluadosXestudianteXservicio(
        CriteriosEvaluadosXestudianteXservicio entity)
        throws Exception {
        criteriosEvaluadosXestudianteXservicioLogic.deleteCriteriosEvaluadosXestudianteXservicio(entity);
    }

    public void updateCriteriosEvaluadosXestudianteXservicio(
        CriteriosEvaluadosXestudianteXservicio entity)
        throws Exception {
        criteriosEvaluadosXestudianteXservicioLogic.updateCriteriosEvaluadosXestudianteXservicio(entity);
    }

    public CriteriosEvaluadosXestudianteXservicio getCriteriosEvaluadosXestudianteXservicio(
        Integer idcriteriosEvaluadosXestudianteXservicio)
        throws Exception {
        CriteriosEvaluadosXestudianteXservicio criteriosEvaluadosXestudianteXservicio =
            null;

        try {
            criteriosEvaluadosXestudianteXservicio = criteriosEvaluadosXestudianteXservicioLogic.getCriteriosEvaluadosXestudianteXservicio(idcriteriosEvaluadosXestudianteXservicio);
        } catch (Exception e) {
            throw e;
        }

        return criteriosEvaluadosXestudianteXservicio;
    }

    public List<CriteriosEvaluadosXestudianteXservicio> findByCriteriaInCriteriosEvaluadosXestudianteXservicio(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return criteriosEvaluadosXestudianteXservicioLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public List<CriteriosEvaluadosXestudianteXservicio> findPageCriteriosEvaluadosXestudianteXservicio(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return criteriosEvaluadosXestudianteXservicioLogic.findPageCriteriosEvaluadosXestudianteXservicio(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberCriteriosEvaluadosXestudianteXservicio()
        throws Exception {
        return criteriosEvaluadosXestudianteXservicioLogic.findTotalNumberCriteriosEvaluadosXestudianteXservicio();
    }

    public List<CriteriosEvaluadosXestudianteXservicioDTO> getDataCriteriosEvaluadosXestudianteXservicio()
        throws Exception {
        return criteriosEvaluadosXestudianteXservicioLogic.getDataCriteriosEvaluadosXestudianteXservicio();
    }

    public List<CriteriosXespacio> getCriteriosXespacio()
        throws Exception {
        return criteriosXespacioLogic.getCriteriosXespacio();
    }

    public void saveCriteriosXespacio(CriteriosXespacio entity)
        throws Exception {
        criteriosXespacioLogic.saveCriteriosXespacio(entity);
    }

    public void deleteCriteriosXespacio(CriteriosXespacio entity)
        throws Exception {
        criteriosXespacioLogic.deleteCriteriosXespacio(entity);
    }

    public void updateCriteriosXespacio(CriteriosXespacio entity)
        throws Exception {
        criteriosXespacioLogic.updateCriteriosXespacio(entity);
    }

    public CriteriosXespacio getCriteriosXespacio(Integer idcriteriosXespacio)
        throws Exception {
        CriteriosXespacio criteriosXespacio = null;

        try {
            criteriosXespacio = criteriosXespacioLogic.getCriteriosXespacio(idcriteriosXespacio);
        } catch (Exception e) {
            throw e;
        }

        return criteriosXespacio;
    }

    public List<CriteriosXespacio> findByCriteriaInCriteriosXespacio(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return criteriosXespacioLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public List<CriteriosXespacio> findPageCriteriosXespacio(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return criteriosXespacioLogic.findPageCriteriosXespacio(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberCriteriosXespacio() throws Exception {
        return criteriosXespacioLogic.findTotalNumberCriteriosXespacio();
    }

    public List<CriteriosXespacioDTO> getDataCriteriosXespacio()
        throws Exception {
        return criteriosXespacioLogic.getDataCriteriosXespacio();
    }

    public List<CriteriosXservicio> getCriteriosXservicio()
        throws Exception {
        return criteriosXservicioLogic.getCriteriosXservicio();
    }

    public void saveCriteriosXservicio(CriteriosXservicio entity)
        throws Exception {
        criteriosXservicioLogic.saveCriteriosXservicio(entity);
    }

    public void deleteCriteriosXservicio(CriteriosXservicio entity)
        throws Exception {
        criteriosXservicioLogic.deleteCriteriosXservicio(entity);
    }

    public void updateCriteriosXservicio(CriteriosXservicio entity)
        throws Exception {
        criteriosXservicioLogic.updateCriteriosXservicio(entity);
    }

    public CriteriosXservicio getCriteriosXservicio(
        Integer idcriteriosXservicio) throws Exception {
        CriteriosXservicio criteriosXservicio = null;

        try {
            criteriosXservicio = criteriosXservicioLogic.getCriteriosXservicio(idcriteriosXservicio);
        } catch (Exception e) {
            throw e;
        }

        return criteriosXservicio;
    }

    public List<CriteriosXservicio> findByCriteriaInCriteriosXservicio(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return criteriosXservicioLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public List<CriteriosXservicio> findPageCriteriosXservicio(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return criteriosXservicioLogic.findPageCriteriosXservicio(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberCriteriosXservicio() throws Exception {
        return criteriosXservicioLogic.findTotalNumberCriteriosXservicio();
    }

    public List<CriteriosXservicioDTO> getDataCriteriosXservicio()
        throws Exception {
        return criteriosXservicioLogic.getDataCriteriosXservicio();
    }

    public List<Curso> getCurso() throws Exception {
        return cursoLogic.getCurso();
    }

    public void saveCurso(Curso entity) throws Exception {
        cursoLogic.saveCurso(entity);
    }

    public void deleteCurso(Curso entity) throws Exception {
        cursoLogic.deleteCurso(entity);
    }

    public void updateCurso(Curso entity) throws Exception {
        cursoLogic.updateCurso(entity);
    }

    public Curso getCurso(Integer idcurso) throws Exception {
        Curso curso = null;

        try {
            curso = cursoLogic.getCurso(idcurso);
        } catch (Exception e) {
            throw e;
        }

        return curso;
    }

    public List<Curso> findByCriteriaInCurso(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return cursoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Curso> findPageCurso(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return cursoLogic.findPageCurso(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberCurso() throws Exception {
        return cursoLogic.findTotalNumberCurso();
    }

    public List<CursoDTO> getDataCurso() throws Exception {
        return cursoLogic.getDataCurso();
    }

    public List<Docente> getDocente() throws Exception {
        return docenteLogic.getDocente();
    }

    public void saveDocente(Docente entity) throws Exception {
        docenteLogic.saveDocente(entity);
    }

    public void deleteDocente(Docente entity) throws Exception {
        docenteLogic.deleteDocente(entity);
    }

    public void updateDocente(Docente entity) throws Exception {
        docenteLogic.updateDocente(entity);
    }

    public Docente getDocente(Integer iddocente) throws Exception {
        Docente docente = null;

        try {
            docente = docenteLogic.getDocente(iddocente);
        } catch (Exception e) {
            throw e;
        }

        return docente;
    }

    public List<Docente> findByCriteriaInDocente(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return docenteLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Docente> findPageDocente(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return docenteLogic.findPageDocente(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberDocente() throws Exception {
        return docenteLogic.findTotalNumberDocente();
    }

    public List<DocenteDTO> getDataDocente() throws Exception {
        return docenteLogic.getDataDocente();
    }

    public List<DocentePrograma> getDocentePrograma() throws Exception {
        return docenteProgramaLogic.getDocentePrograma();
    }

    public void saveDocentePrograma(DocentePrograma entity)
        throws Exception {
        docenteProgramaLogic.saveDocentePrograma(entity);
    }

    public void deleteDocentePrograma(DocentePrograma entity)
        throws Exception {
        docenteProgramaLogic.deleteDocentePrograma(entity);
    }

    public void updateDocentePrograma(DocentePrograma entity)
        throws Exception {
        docenteProgramaLogic.updateDocentePrograma(entity);
    }

    public DocentePrograma getDocentePrograma(Integer iddocentePrograma)
        throws Exception {
        DocentePrograma docentePrograma = null;

        try {
            docentePrograma = docenteProgramaLogic.getDocentePrograma(iddocentePrograma);
        } catch (Exception e) {
            throw e;
        }

        return docentePrograma;
    }

    public List<DocentePrograma> findByCriteriaInDocentePrograma(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return docenteProgramaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<DocentePrograma> findPageDocentePrograma(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return docenteProgramaLogic.findPageDocentePrograma(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberDocentePrograma() throws Exception {
        return docenteProgramaLogic.findTotalNumberDocentePrograma();
    }

    public List<DocenteProgramaDTO> getDataDocentePrograma()
        throws Exception {
        return docenteProgramaLogic.getDataDocentePrograma();
    }
    

    public List<GruposOpcionesDTO> consultarNombresGruposPrograma(int codigo) throws Exception {
    	return programaLogic.consultarNombresGrupos(codigo);
    }

    public List<OpcionesDTO> consultarOpcionesPrograma(int codigo) throws Exception {
    	return programaLogic.consultarOpciones(codigo);
    }
    

    public List<Espacio> getEspacio() throws Exception {
        return espacioLogic.getEspacio();
    }

    public void saveEspacio(Espacio entity) throws Exception {
        espacioLogic.saveEspacio(entity);
    }

    public void deleteEspacio(Espacio entity) throws Exception {
        espacioLogic.deleteEspacio(entity);
    }

    public void updateEspacio(Espacio entity) throws Exception {
        espacioLogic.updateEspacio(entity);
    }

    public Espacio getEspacio(Integer idespacio) throws Exception {
        Espacio espacio = null;

        try {
            espacio = espacioLogic.getEspacio(idespacio);
        } catch (Exception e) {
            throw e;
        }

        return espacio;
    }

    public List<Espacio> findByCriteriaInEspacio(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return espacioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Espacio> findPageEspacio(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return espacioLogic.findPageEspacio(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberEspacio() throws Exception {
        return espacioLogic.findTotalNumberEspacio();
    }

    public List<EspacioDTO> getDataEspacio() throws Exception {
        return espacioLogic.getDataEspacio();
    }

    public List<Estudiante> getEstudiante() throws Exception {
        return estudianteLogic.getEstudiante();
    }

    public void saveEstudiante(Estudiante entity) throws Exception {
        estudianteLogic.saveEstudiante(entity);
    }

    public void deleteEstudiante(Estudiante entity) throws Exception {
        estudianteLogic.deleteEstudiante(entity);
    }

    public void updateEstudiante(Estudiante entity) throws Exception {
        estudianteLogic.updateEstudiante(entity);
    }

    public Estudiante getEstudiante(Integer idestudiante)
        throws Exception {
        Estudiante estudiante = null;

        try {
            estudiante = estudianteLogic.getEstudiante(idestudiante);
        } catch (Exception e) {
            throw e;
        }

        return estudiante;
    }

    public List<Estudiante> findByCriteriaInEstudiante(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return estudianteLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Estudiante> findPageEstudiante(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return estudianteLogic.findPageEstudiante(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberEstudiante() throws Exception {
        return estudianteLogic.findTotalNumberEstudiante();
    }

    public List<EstudianteDTO> getDataEstudiante() throws Exception {
        return estudianteLogic.getDataEstudiante();
    }

    public List<EstudianteCurso> getEstudianteCurso() throws Exception {
        return estudianteCursoLogic.getEstudianteCurso();
    }

    public void saveEstudianteCurso(EstudianteCurso entity)
        throws Exception {
        estudianteCursoLogic.saveEstudianteCurso(entity);
    }

    public void deleteEstudianteCurso(EstudianteCurso entity)
        throws Exception {
        estudianteCursoLogic.deleteEstudianteCurso(entity);
    }

    public void updateEstudianteCurso(EstudianteCurso entity)
        throws Exception {
        estudianteCursoLogic.updateEstudianteCurso(entity);
    }

    public EstudianteCurso getEstudianteCurso(Integer idestudianteCurso)
        throws Exception {
        EstudianteCurso estudianteCurso = null;

        try {
            estudianteCurso = estudianteCursoLogic.getEstudianteCurso(idestudianteCurso);
        } catch (Exception e) {
            throw e;
        }

        return estudianteCurso;
    }

    public List<EstudianteCurso> findByCriteriaInEstudianteCurso(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return estudianteCursoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<EstudianteCurso> findPageEstudianteCurso(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return estudianteCursoLogic.findPageEstudianteCurso(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberEstudianteCurso() throws Exception {
        return estudianteCursoLogic.findTotalNumberEstudianteCurso();
    }

    public List<EstudianteCursoDTO> getDataEstudianteCurso()
        throws Exception {
        return estudianteCursoLogic.getDataEstudianteCurso();
    }

    public List<Facultad> getFacultad() throws Exception {
        return facultadLogic.getFacultad();
    }

    public void saveFacultad(Facultad entity) throws Exception {
        facultadLogic.saveFacultad(entity);
    }

    public void deleteFacultad(Facultad entity) throws Exception {
        facultadLogic.deleteFacultad(entity);
    }

    public void updateFacultad(Facultad entity) throws Exception {
        facultadLogic.updateFacultad(entity);
    }

    public Facultad getFacultad(Integer idfacultad) throws Exception {
        Facultad facultad = null;

        try {
            facultad = facultadLogic.getFacultad(idfacultad);
        } catch (Exception e) {
            throw e;
        }

        return facultad;
    }

    public List<Facultad> findByCriteriaInFacultad(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return facultadLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Facultad> findPageFacultad(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return facultadLogic.findPageFacultad(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberFacultad() throws Exception {
        return facultadLogic.findTotalNumberFacultad();
    }

    public List<FacultadDTO> getDataFacultad() throws Exception {
        return facultadLogic.getDataFacultad();
    }
    

    public List<GruposOpcionesDTO> consultarNombresGruposFacultad(int codigo) throws Exception {
    	return facultadLogic.consultarNombresGrupos(codigo);
    }

    public List<OpcionesDTO> consultarOpcionesFacultad(int codigo) throws Exception {
    	return facultadLogic.consultarOpciones(codigo);
    }
    

    public List<GruposOpciones> getGruposOpciones() throws Exception {
        return gruposOpcionesLogic.getGruposOpciones();
    }

    public void saveGruposOpciones(GruposOpciones entity)
        throws Exception {
        gruposOpcionesLogic.saveGruposOpciones(entity);
    }

    public void deleteGruposOpciones(GruposOpciones entity)
        throws Exception {
        gruposOpcionesLogic.deleteGruposOpciones(entity);
    }

    public void updateGruposOpciones(GruposOpciones entity)
        throws Exception {
        gruposOpcionesLogic.updateGruposOpciones(entity);
    }

    public GruposOpciones getGruposOpciones(Integer idgruposOpciones)
        throws Exception {
        GruposOpciones gruposOpciones = null;

        try {
            gruposOpciones = gruposOpcionesLogic.getGruposOpciones(idgruposOpciones);
        } catch (Exception e) {
            throw e;
        }

        return gruposOpciones;
    }

    public List<GruposOpciones> findByCriteriaInGruposOpciones(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return gruposOpcionesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<GruposOpciones> findPageGruposOpciones(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return gruposOpcionesLogic.findPageGruposOpciones(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberGruposOpciones() throws Exception {
        return gruposOpcionesLogic.findTotalNumberGruposOpciones();
    }

    public List<GruposOpcionesDTO> getDataGruposOpciones()
        throws Exception {
        return gruposOpcionesLogic.getDataGruposOpciones();
    }

    public List<HistorialCriteriosEvaluadosXestuadianteXservicio> getHistorialCriteriosEvaluadosXestuadianteXservicio()
        throws Exception {
        return historialCriteriosEvaluadosXestuadianteXservicioLogic.getHistorialCriteriosEvaluadosXestuadianteXservicio();
    }

    public void saveHistorialCriteriosEvaluadosXestuadianteXservicio(
        HistorialCriteriosEvaluadosXestuadianteXservicio entity)
        throws Exception {
        historialCriteriosEvaluadosXestuadianteXservicioLogic.saveHistorialCriteriosEvaluadosXestuadianteXservicio(entity);
    }

    public void deleteHistorialCriteriosEvaluadosXestuadianteXservicio(
        HistorialCriteriosEvaluadosXestuadianteXservicio entity)
        throws Exception {
        historialCriteriosEvaluadosXestuadianteXservicioLogic.deleteHistorialCriteriosEvaluadosXestuadianteXservicio(entity);
    }

    public void updateHistorialCriteriosEvaluadosXestuadianteXservicio(
        HistorialCriteriosEvaluadosXestuadianteXservicio entity)
        throws Exception {
        historialCriteriosEvaluadosXestuadianteXservicioLogic.updateHistorialCriteriosEvaluadosXestuadianteXservicio(entity);
    }

    public HistorialCriteriosEvaluadosXestuadianteXservicio getHistorialCriteriosEvaluadosXestuadianteXservicio(
        Integer idhistorialCriteriosEvaluadosXestuadianteXservicio)
        throws Exception {
        HistorialCriteriosEvaluadosXestuadianteXservicio historialCriteriosEvaluadosXestuadianteXservicio =
            null;

        try {
            historialCriteriosEvaluadosXestuadianteXservicio = historialCriteriosEvaluadosXestuadianteXservicioLogic.getHistorialCriteriosEvaluadosXestuadianteXservicio(idhistorialCriteriosEvaluadosXestuadianteXservicio);
        } catch (Exception e) {
            throw e;
        }

        return historialCriteriosEvaluadosXestuadianteXservicio;
    }

    public List<HistorialCriteriosEvaluadosXestuadianteXservicio> findByCriteriaInHistorialCriteriosEvaluadosXestuadianteXservicio(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return historialCriteriosEvaluadosXestuadianteXservicioLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public List<HistorialCriteriosEvaluadosXestuadianteXservicio> findPageHistorialCriteriosEvaluadosXestuadianteXservicio(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return historialCriteriosEvaluadosXestuadianteXservicioLogic.findPageHistorialCriteriosEvaluadosXestuadianteXservicio(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberHistorialCriteriosEvaluadosXestuadianteXservicio()
        throws Exception {
        return historialCriteriosEvaluadosXestuadianteXservicioLogic.findTotalNumberHistorialCriteriosEvaluadosXestuadianteXservicio();
    }

    public List<HistorialCriteriosEvaluadosXestuadianteXservicioDTO> getDataHistorialCriteriosEvaluadosXestuadianteXservicio()
        throws Exception {
        return historialCriteriosEvaluadosXestuadianteXservicioLogic.getDataHistorialCriteriosEvaluadosXestuadianteXservicio();
    }

    public List<HistorialCriteriosEvaluadosXestudianteXespacio> getHistorialCriteriosEvaluadosXestudianteXespacio()
        throws Exception {
        return historialCriteriosEvaluadosXestudianteXespacioLogic.getHistorialCriteriosEvaluadosXestudianteXespacio();
    }

    public void saveHistorialCriteriosEvaluadosXestudianteXespacio(
        HistorialCriteriosEvaluadosXestudianteXespacio entity)
        throws Exception {
        historialCriteriosEvaluadosXestudianteXespacioLogic.saveHistorialCriteriosEvaluadosXestudianteXespacio(entity);
    }

    public void deleteHistorialCriteriosEvaluadosXestudianteXespacio(
        HistorialCriteriosEvaluadosXestudianteXespacio entity)
        throws Exception {
        historialCriteriosEvaluadosXestudianteXespacioLogic.deleteHistorialCriteriosEvaluadosXestudianteXespacio(entity);
    }

    public void updateHistorialCriteriosEvaluadosXestudianteXespacio(
        HistorialCriteriosEvaluadosXestudianteXespacio entity)
        throws Exception {
        historialCriteriosEvaluadosXestudianteXespacioLogic.updateHistorialCriteriosEvaluadosXestudianteXespacio(entity);
    }

    public HistorialCriteriosEvaluadosXestudianteXespacio getHistorialCriteriosEvaluadosXestudianteXespacio(
        Integer idhistorialEvaluacionXestudianteXespacio)
        throws Exception {
        HistorialCriteriosEvaluadosXestudianteXespacio historialCriteriosEvaluadosXestudianteXespacio =
            null;

        try {
            historialCriteriosEvaluadosXestudianteXespacio = historialCriteriosEvaluadosXestudianteXespacioLogic.getHistorialCriteriosEvaluadosXestudianteXespacio(idhistorialEvaluacionXestudianteXespacio);
        } catch (Exception e) {
            throw e;
        }

        return historialCriteriosEvaluadosXestudianteXespacio;
    }

    public List<HistorialCriteriosEvaluadosXestudianteXespacio> findByCriteriaInHistorialCriteriosEvaluadosXestudianteXespacio(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return historialCriteriosEvaluadosXestudianteXespacioLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public List<HistorialCriteriosEvaluadosXestudianteXespacio> findPageHistorialCriteriosEvaluadosXestudianteXespacio(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        return historialCriteriosEvaluadosXestudianteXespacioLogic.findPageHistorialCriteriosEvaluadosXestudianteXespacio(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberHistorialCriteriosEvaluadosXestudianteXespacio()
        throws Exception {
        return historialCriteriosEvaluadosXestudianteXespacioLogic.findTotalNumberHistorialCriteriosEvaluadosXestudianteXespacio();
    }

    public List<HistorialCriteriosEvaluadosXestudianteXespacioDTO> getDataHistorialCriteriosEvaluadosXestudianteXespacio()
        throws Exception {
        return historialCriteriosEvaluadosXestudianteXespacioLogic.getDataHistorialCriteriosEvaluadosXestudianteXespacio();
    }

    public List<Opciones> getOpciones() throws Exception {
        return opcionesLogic.getOpciones();
    }

    public void saveOpciones(Opciones entity) throws Exception {
        opcionesLogic.saveOpciones(entity);
    }

    public void deleteOpciones(Opciones entity) throws Exception {
        opcionesLogic.deleteOpciones(entity);
    }

    public void updateOpciones(Opciones entity) throws Exception {
        opcionesLogic.updateOpciones(entity);
    }

    public Opciones getOpciones(Integer idopciones) throws Exception {
        Opciones opciones = null;

        try {
            opciones = opcionesLogic.getOpciones(idopciones);
        } catch (Exception e) {
            throw e;
        }

        return opciones;
    }

    public List<Opciones> findByCriteriaInOpciones(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return opcionesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Opciones> findPageOpciones(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return opcionesLogic.findPageOpciones(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberOpciones() throws Exception {
        return opcionesLogic.findTotalNumberOpciones();
    }

    public List<OpcionesDTO> getDataOpciones() throws Exception {
        return opcionesLogic.getDataOpciones();
    }

    public List<Permisos> getPermisos() throws Exception {
        return permisosLogic.getPermisos();
    }

    public void savePermisos(Permisos entity) throws Exception {
        permisosLogic.savePermisos(entity);
    }

    public void deletePermisos(Permisos entity) throws Exception {
        permisosLogic.deletePermisos(entity);
    }

    public void updatePermisos(Permisos entity) throws Exception {
        permisosLogic.updatePermisos(entity);
    }

    public Permisos getPermisos(Integer idpermisos) throws Exception {
        Permisos permisos = null;

        try {
            permisos = permisosLogic.getPermisos(idpermisos);
        } catch (Exception e) {
            throw e;
        }

        return permisos;
    }

    public List<Permisos> findByCriteriaInPermisos(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return permisosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Permisos> findPagePermisos(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return permisosLogic.findPagePermisos(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberPermisos() throws Exception {
        return permisosLogic.findTotalNumberPermisos();
    }

    public List<PermisosDTO> getDataPermisos() throws Exception {
        return permisosLogic.getDataPermisos();
    }
    


    public List<Programa> getPrograma() throws Exception {
        return programaLogic.getPrograma();
    }

    public void savePrograma(Programa entity) throws Exception {
        programaLogic.savePrograma(entity);
    }

    public void deletePrograma(Programa entity) throws Exception {
        programaLogic.deletePrograma(entity);
    }

    public void updatePrograma(Programa entity) throws Exception {
        programaLogic.updatePrograma(entity);
    }

    public Programa getPrograma(Integer idprograma) throws Exception {
        Programa programa = null;

        try {
            programa = programaLogic.getPrograma(idprograma);
        } catch (Exception e) {
            throw e;
        }

        return programa;
    }

    public List<Programa> findByCriteriaInPrograma(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return programaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Programa> findPagePrograma(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return programaLogic.findPagePrograma(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberPrograma() throws Exception {
        return programaLogic.findTotalNumberPrograma();
    }

    public List<ProgramaDTO> getDataPrograma() throws Exception {
        return programaLogic.getDataPrograma();
    }

    public List<Servicio> getServicio() throws Exception {
        return servicioLogic.getServicio();
    }

    public void saveServicio(Servicio entity) throws Exception {
        servicioLogic.saveServicio(entity);
    }

    public void deleteServicio(Servicio entity) throws Exception {
        servicioLogic.deleteServicio(entity);
    }

    public void updateServicio(Servicio entity) throws Exception {
        servicioLogic.updateServicio(entity);
    }

    public Servicio getServicio(Integer idservicio) throws Exception {
        Servicio servicio = null;

        try {
            servicio = servicioLogic.getServicio(idservicio);
        } catch (Exception e) {
            throw e;
        }

        return servicio;
    }

    public List<Servicio> findByCriteriaInServicio(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return servicioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Servicio> findPageServicio(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return servicioLogic.findPageServicio(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberServicio() throws Exception {
        return servicioLogic.findTotalNumberServicio();
    }

    public List<ServicioDTO> getDataServicio() throws Exception {
        return servicioLogic.getDataServicio();
    }

    public List<TipoCriterios> getTipoCriterios() throws Exception {
        return tipoCriteriosLogic.getTipoCriterios();
    }

    public void saveTipoCriterios(TipoCriterios entity)
        throws Exception {
        tipoCriteriosLogic.saveTipoCriterios(entity);
    }

    public void deleteTipoCriterios(TipoCriterios entity)
        throws Exception {
        tipoCriteriosLogic.deleteTipoCriterios(entity);
    }

    public void updateTipoCriterios(TipoCriterios entity)
        throws Exception {
        tipoCriteriosLogic.updateTipoCriterios(entity);
    }

    public TipoCriterios getTipoCriterios(Integer idtipoCriterios)
        throws Exception {
        TipoCriterios tipoCriterios = null;

        try {
            tipoCriterios = tipoCriteriosLogic.getTipoCriterios(idtipoCriterios);
        } catch (Exception e) {
            throw e;
        }

        return tipoCriterios;
    }

    public List<TipoCriterios> findByCriteriaInTipoCriterios(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        return tipoCriteriosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<TipoCriterios> findPageTipoCriterios(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return tipoCriteriosLogic.findPageTipoCriterios(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberTipoCriterios() throws Exception {
        return tipoCriteriosLogic.findTotalNumberTipoCriterios();
    }

    public List<TipoCriteriosDTO> getDataTipoCriterios()
        throws Exception {
        return tipoCriteriosLogic.getDataTipoCriterios();
    }

    public List<Universidad> getUniversidad() throws Exception {
        return universidadLogic.getUniversidad();
    }

    public void saveUniversidad(Universidad entity) throws Exception {
        universidadLogic.saveUniversidad(entity);
    }

    public void deleteUniversidad(Universidad entity) throws Exception {
        universidadLogic.deleteUniversidad(entity);
    }

    public void updateUniversidad(Universidad entity) throws Exception {
        universidadLogic.updateUniversidad(entity);
    }

    public Universidad getUniversidad(Integer iduniversidad)
        throws Exception {
        Universidad universidad = null;

        try {
            universidad = universidadLogic.getUniversidad(iduniversidad);
        } catch (Exception e) {
            throw e;
        }

        return universidad;
    }

    public List<Universidad> findByCriteriaInUniversidad(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return universidadLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Universidad> findPageUniversidad(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return universidadLogic.findPageUniversidad(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public Long findTotalNumberUniversidad() throws Exception {
        return universidadLogic.findTotalNumberUniversidad();
    }

    public List<UniversidadDTO> getDataUniversidad() throws Exception {
        return universidadLogic.getDataUniversidad();
    }


	public List<OpcionesDTO> consultarOpciones(int codigo) throws Exception {
		return universidadLogic.consultarOpciones(codigo);
	}


	public List<GruposOpcionesDTO> consultarNombresGrupos(int codigo) throws Exception{
		return universidadLogic.consultarNombresGrupos(codigo);
	}
    
    
    
    
    public List<Usuario> getUsuario() throws Exception {
        return usuarioLogic.getUsuario();
    }

    public void saveUsuario(Usuario entity) throws Exception {
        usuarioLogic.saveUsuario(entity);
    }

    public void deleteUsuario(Usuario entity) throws Exception {
        usuarioLogic.deleteUsuario(entity);
    }

    public void updateUsuario(Usuario entity) throws Exception {
        usuarioLogic.updateUsuario(entity);
    }

    public Usuario getUsuario(String usu) throws Exception {
        Usuario usuario = null;

        try {
            usuario = usuarioLogic.getUsuario(usu);
        } catch (Exception e) {
            throw e;
        }

        return usuario;
    }

    public List<Usuario> findByCriteriaInUsuario(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        return usuarioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public List<Usuario> findPageUsuario(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        return usuarioLogic.findPageUsuario(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public Long findTotalNumberUsuario() throws Exception {
        return usuarioLogic.findTotalNumberUsuario();
    }

    public List<UsuarioDTO> getDataUsuario() throws Exception {
        return usuarioLogic.getDataUsuario();
    }
    
    public String getRol(Usuario entity) throws Exception{
    	return usuarioLogic.getRol(entity);
    }
}
